diff --git a/fdbbackup/backup.actor.cpp b/fdbbackup/backup.actor.cpp index 53260c923c..76ef44c633 100644 --- a/fdbbackup/backup.actor.cpp +++ b/fdbbackup/backup.actor.cpp @@ -1449,7 +1449,7 @@ ACTOR Future getLayerStatus(Reference tr for (KeyBackedTag eachTag : backupTags) { Version last_restorable_version = tagLastRestorableVersions[j].get(); double last_restorable_seconds_behind = ((double)readVer - last_restorable_version) / CLIENT_KNOBS->CORE_VERSIONSPERSECOND; - BackupAgentBase::enumState status = (BackupAgentBase::enumState)tagStates[j].get(); + EBackupState status = tagStates[j].get(); const char *statusText = fba.getStateText(status); // The object for this backup tag inside this instance's subdocument @@ -1458,8 +1458,9 @@ ACTOR Future getLayerStatus(Reference tr tagRoot.create("current_status") = statusText; tagRoot.create("last_restorable_version") = tagLastRestorableVersions[j].get(); tagRoot.create("last_restorable_seconds_behind") = last_restorable_seconds_behind; - tagRoot.create("running_backup") = (status == BackupAgentBase::STATE_RUNNING_DIFFERENTIAL || status == BackupAgentBase::STATE_RUNNING); - tagRoot.create("running_backup_is_restorable") = (status == BackupAgentBase::STATE_RUNNING_DIFFERENTIAL); + tagRoot.create("running_backup") = + (status == EBackupState::STATE_RUNNING_DIFFERENTIAL || status == EBackupState::STATE_RUNNING); + tagRoot.create("running_backup_is_restorable") = (status == EBackupState::STATE_RUNNING_DIFFERENTIAL); tagRoot.create("range_bytes_written") = tagRangeBytes[j].get(); tagRoot.create("mutation_log_bytes_written") = tagLogBytes[j].get(); tagRoot.create("mutation_stream_id") = backupTagUids[j].toString(); @@ -1474,7 +1475,7 @@ ACTOR Future getLayerStatus(Reference tr tr2->setOption(FDBTransactionOptions::LOCK_AWARE); state Standalone tagNames = wait(tr2->getRange(dba.tagNames.range(), 10000, snapshot)); state std::vector>> backupVersion; - state std::vector> backupStatus; + state std::vector> backupStatus; state std::vector> tagRangeBytesDR; state std::vector> tagLogBytesDR; state Future> fDRPaused = tr->get(dba.taskBucket->getPauseKey(), snapshot); @@ -1499,11 +1500,12 @@ ACTOR Future getLayerStatus(Reference tr for (int i = 0; i < tagNames.size(); i++) { std::string tagName = dba.sourceTagNames.unpack(tagNames[i].key).getString(0).toString(); - BackupAgentBase::enumState status = (BackupAgentBase::enumState)backupStatus[i].get(); + auto status = backupStatus[i].get(); JSONDoc tagRoot = tagsRoot.create(tagName); - tagRoot.create("running_backup") = (status == BackupAgentBase::STATE_RUNNING_DIFFERENTIAL || status == BackupAgentBase::STATE_RUNNING); - tagRoot.create("running_backup_is_restorable") = (status == BackupAgentBase::STATE_RUNNING_DIFFERENTIAL); + tagRoot.create("running_backup") = + (status == EBackupState::STATE_RUNNING_DIFFERENTIAL || status == EBackupState::STATE_RUNNING); + tagRoot.create("running_backup_is_restorable") = (status == EBackupState::STATE_RUNNING_DIFFERENTIAL); tagRoot.create("range_bytes_written") = tagRangeBytesDR[i].get(); tagRoot.create("mutation_log_bytes_written") = tagLogBytesDR[i].get(); tagRoot.create("mutation_stream_id") = drTagUids[i].toString(); @@ -1787,7 +1789,7 @@ ACTOR Future submitBackup(Database db, std::string url, int snapshotInterv EBackupState backupStatus = wait(config.stateEnum().getOrThrow(db)); // Throw error if a backup is currently running until we support parallel backups - if (BackupAgentBase::isRunnable((BackupAgentBase::enumState)backupStatus)) { + if (BackupAgentBase::isRunnable(backupStatus)) { throw backup_duplicate(); } } @@ -2012,10 +2014,10 @@ ACTOR Future waitBackup(Database db, std::string tagName, bool stopWhenDon { state FileBackupAgent backupAgent; - int status = wait(backupAgent.waitBackup(db, tagName, stopWhenDone)); + EBackupState status = wait(backupAgent.waitBackup(db, tagName, stopWhenDone)); printf("The backup on tag `%s' %s.\n", printable(StringRef(tagName)).c_str(), - BackupAgentBase::getStateText((BackupAgentBase::enumState) status)); + BackupAgentBase::getStateText(status)); } catch (Error& e) { if(e.code() == error_code_actor_cancelled) diff --git a/fdbclient/BackupAgent.actor.h b/fdbclient/BackupAgent.actor.h index 927295952e..4b27c9e8d9 100644 --- a/fdbclient/BackupAgent.actor.h +++ b/fdbclient/BackupAgent.actor.h @@ -46,13 +46,15 @@ public: return "YYYY/MM/DD.HH:MI:SS[+/-]HHMM"; } - // Type of program being executed - enum enumActionResult { - RESULT_SUCCESSFUL = 0, RESULT_ERRORED = 1, RESULT_DUPLICATE = 2, RESULT_UNNEEDED = 3 - }; - - enum enumState { - STATE_ERRORED = 0, STATE_SUBMITTED = 1, STATE_RUNNING = 2, STATE_RUNNING_DIFFERENTIAL = 3, STATE_COMPLETED = 4, STATE_NEVERRAN = 5, STATE_ABORTED = 6, STATE_PARTIALLY_ABORTED = 7 + enum class EnumState { + STATE_ERRORED = 0, + STATE_SUBMITTED = 1, + STATE_RUNNING = 2, + STATE_RUNNING_DIFFERENTIAL = 3, + STATE_COMPLETED = 4, + STATE_NEVERRAN = 5, + STATE_ABORTED = 6, + STATE_PARTIALLY_ABORTED = 7 }; static const Key keyFolderId; @@ -85,70 +87,68 @@ public: static const int logHeaderSize; // Convert the status text to an enumerated value - static enumState getState(std::string stateText) - { - enumState enState = STATE_ERRORED; + static EnumState getState(std::string stateText) { + auto enState = EnumState::STATE_ERRORED; if (stateText.empty()) { - enState = STATE_NEVERRAN; + enState = EnumState::STATE_NEVERRAN; } else if (!stateText.compare("has been submitted")) { - enState = STATE_SUBMITTED; + enState = EnumState::STATE_SUBMITTED; } else if (!stateText.compare("has been started")) { - enState = STATE_RUNNING; + enState = EnumState::STATE_RUNNING; } else if (!stateText.compare("is differential")) { - enState = STATE_RUNNING_DIFFERENTIAL; + enState = EnumState::STATE_RUNNING_DIFFERENTIAL; } else if (!stateText.compare("has been completed")) { - enState = STATE_COMPLETED; + enState = EnumState::STATE_COMPLETED; } else if (!stateText.compare("has been aborted")) { - enState = STATE_ABORTED; + enState = EnumState::STATE_ABORTED; } else if (!stateText.compare("has been partially aborted")) { - enState = STATE_PARTIALLY_ABORTED; + enState = EnumState::STATE_PARTIALLY_ABORTED; } return enState; } // Convert the status enum to a text description - static const char* getStateText(enumState enState) - { + static const char* getStateText(EnumState enState) { const char* stateText; switch (enState) { - case STATE_ERRORED: + case EnumState::STATE_ERRORED: stateText = "has errored"; break; - case STATE_NEVERRAN: + case EnumState::STATE_NEVERRAN: stateText = "has never been started"; break; - case STATE_SUBMITTED: + case EnumState::STATE_SUBMITTED: stateText = "has been submitted"; break; - case STATE_RUNNING: + case EnumState::STATE_RUNNING: stateText = "has been started"; break; - case STATE_RUNNING_DIFFERENTIAL: + case EnumState::STATE_RUNNING_DIFFERENTIAL: stateText = "is differential"; break; - case STATE_COMPLETED: + case EnumState::STATE_COMPLETED: stateText = "has been completed"; break; - case STATE_ABORTED: + case EnumState::STATE_ABORTED: stateText = "has been aborted"; break; - case STATE_PARTIALLY_ABORTED: + case EnumState::STATE_PARTIALLY_ABORTED: stateText = "has been partially aborted"; break; default: @@ -160,34 +160,33 @@ public: } // Convert the status enum to a name - static const char* getStateName(enumState enState) - { + static const char* getStateName(EnumState enState) { const char* s; switch (enState) { - case STATE_ERRORED: + case EnumState::STATE_ERRORED: s = "Errored"; break; - case STATE_NEVERRAN: + case EnumState::STATE_NEVERRAN: s = "NeverRan"; break; - case STATE_SUBMITTED: + case EnumState::STATE_SUBMITTED: s = "Submitted"; break; - case STATE_RUNNING: + case EnumState::STATE_RUNNING: s = "Running"; break; - case STATE_RUNNING_DIFFERENTIAL: + case EnumState::STATE_RUNNING_DIFFERENTIAL: s = "RunningDifferentially"; break; - case STATE_COMPLETED: + case EnumState::STATE_COMPLETED: s = "Completed"; break; - case STATE_ABORTED: + case EnumState::STATE_ABORTED: s = "Aborted"; break; - case STATE_PARTIALLY_ABORTED: + case EnumState::STATE_PARTIALLY_ABORTED: s = "Aborting"; break; default: @@ -199,16 +198,15 @@ public: } // Determine if the specified state is runnable - static bool isRunnable(enumState enState) - { + static bool isRunnable(EnumState enState) { bool isRunnable = false; switch (enState) { - case STATE_SUBMITTED: - case STATE_RUNNING: - case STATE_RUNNING_DIFFERENTIAL: - case STATE_PARTIALLY_ABORTED: + case EnumState::STATE_SUBMITTED: + case EnumState::STATE_RUNNING: + case EnumState::STATE_RUNNING_DIFFERENTIAL: + case EnumState::STATE_PARTIALLY_ABORTED: isRunnable = true; break; default: @@ -359,7 +357,8 @@ public: // stopWhenDone will return when the backup is stopped, if enabled. Otherwise, it // will return when the backup directory is restorable. - Future waitBackup(Database cx, std::string tagName, bool stopWhenDone = true, Reference *pContainer = nullptr, UID *pUID = nullptr); + Future waitBackup(Database cx, std::string tagName, bool stopWhenDone = true, + Reference* pContainer = nullptr, UID* pUID = nullptr); static const Key keyLastRestorable; @@ -432,8 +431,8 @@ public: Future getStatus(Database cx, int errorLimit, Key tagName); - Future getStateValue(Reference tr, UID logUid, bool snapshot = false); - Future getStateValue(Database cx, UID logUid) { + Future getStateValue(Reference tr, UID logUid, bool snapshot = false); + Future getStateValue(Database cx, UID logUid) { return runRYWTransaction(cx, [=](Reference tr){ return getStateValue(tr, logUid); }); } @@ -452,8 +451,8 @@ public: // stopWhenDone will return when the backup is stopped, if enabled. Otherwise, it // will return when the backup directory is restorable. - Future waitBackup(Database cx, Key tagName, bool stopWhenDone = true); - Future waitSubmitted(Database cx, Key tagName); + Future waitBackup(Database cx, Key tagName, bool stopWhenDone = true); + Future waitSubmitted(Database cx, Key tagName); Future waitUpgradeToLatestDrVersion(Database cx, Key tagName); static const Key keyAddPrefix; @@ -522,9 +521,15 @@ ACTOR Future applyMutations(Database cx, Key uid, Key addPrefix, Key remov NotifiedVersion* committedVersion, Reference> keyVersion); ACTOR Future cleanupBackup(Database cx, bool deleteData); -typedef BackupAgentBase::enumState EBackupState; -template<> inline Tuple Codec::pack(EBackupState const &val) { return Tuple().append(val); } -template<> inline EBackupState Codec::unpack(Tuple const &val) { return (EBackupState)val.getInt(0); } +using EBackupState = BackupAgentBase::EnumState; +template <> +inline Tuple Codec::pack(EBackupState const& val) { + return Tuple().append(static_cast(val)); +} +template <> +inline EBackupState Codec::unpack(Tuple const& val) { + return static_cast(val.getInt(0)); +} // Key backed tags are a single-key slice of the TagUidMap, defined below. // The Value type of the key is a UidAndAbortedFlagT which is a pair of {UID, aborted_flag} diff --git a/fdbclient/DatabaseBackupAgent.actor.cpp b/fdbclient/DatabaseBackupAgent.actor.cpp index 1162986e10..81c865d09a 100644 --- a/fdbclient/DatabaseBackupAgent.actor.cpp +++ b/fdbclient/DatabaseBackupAgent.actor.cpp @@ -965,9 +965,10 @@ namespace dbBackup { tr->clear(KeyRangeRef(logsPath, strinc(logsPath))); tr->clear(conf.range()); - tr->set(states.pack(DatabaseBackupAgent::keyStateStatus), StringRef(BackupAgentBase::getStateText(BackupAgentBase::STATE_COMPLETED))); + tr->set(states.pack(DatabaseBackupAgent::keyStateStatus), + StringRef(BackupAgentBase::getStateText(EBackupState::STATE_COMPLETED))); - wait(taskBucket->finish(tr, task)); + wait(taskBucket->finish(tr, task)); return Void(); } @@ -1449,9 +1450,10 @@ namespace dbBackup { try { tr.setOption(FDBTransactionOptions::LOCK_AWARE); tr.addReadConflictRange(singleKeyRange(sourceStates.pack(DatabaseBackupAgent::keyStateStatus))); - tr.set(sourceStates.pack(DatabaseBackupAgent::keyStateStatus), StringRef(BackupAgentBase::getStateText(BackupAgentBase::STATE_RUNNING_DIFFERENTIAL))); + tr.set(sourceStates.pack(DatabaseBackupAgent::keyStateStatus), + StringRef(BackupAgentBase::getStateText(EBackupState::STATE_RUNNING_DIFFERENTIAL))); - Key versionKey = task->params[DatabaseBackupAgent::keyConfigLogUid].withPrefix(task->params[BackupAgentBase::destUid]).withPrefix(backupLatestVersionsPrefix); + Key versionKey = task->params[DatabaseBackupAgent::keyConfigLogUid].withPrefix(task->params[BackupAgentBase::destUid]).withPrefix(backupLatestVersionsPrefix); Optional prevBeginVersion = wait(tr.get(versionKey)); if (!prevBeginVersion.present()) { return Void(); @@ -1489,9 +1491,10 @@ namespace dbBackup { wait(success(FinishedFullBackupTaskFunc::addTask(tr, taskBucket, task, TaskCompletionKey::noSignal()))); } else { // Start the writing of logs, if differential - tr->set(states.pack(DatabaseBackupAgent::keyStateStatus), StringRef(BackupAgentBase::getStateText(BackupAgentBase::STATE_RUNNING_DIFFERENTIAL))); + tr->set(states.pack(DatabaseBackupAgent::keyStateStatus), + StringRef(BackupAgentBase::getStateText(EBackupState::STATE_RUNNING_DIFFERENTIAL))); - allPartsDone = futureBucket->future(tr); + allPartsDone = futureBucket->future(tr); Version prevBeginVersion = BinaryReader::fromStringRef(task->params[DatabaseBackupAgent::keyPrevBeginVersion], Unversioned()); wait(success(CopyDiffLogsTaskFunc::addTask(tr, taskBucket, task, prevBeginVersion, restoreVersion, TaskCompletionKey::joinWith(allPartsDone)))); @@ -1623,9 +1626,10 @@ namespace dbBackup { srcTr2->set( Subspace(databaseBackupPrefixRange.begin).get(BackupAgentBase::keySourceTagName).pack(task->params[BackupAgentBase::keyTagName]), logUidValue ); srcTr2->set( sourceStates.pack(DatabaseBackupAgent::keyFolderId), task->params[DatabaseBackupAgent::keyFolderId] ); - srcTr2->set( sourceStates.pack(DatabaseBackupAgent::keyStateStatus), StringRef(BackupAgentBase::getStateText(BackupAgentBase::STATE_RUNNING))); + srcTr2->set(sourceStates.pack(DatabaseBackupAgent::keyStateStatus), + StringRef(BackupAgentBase::getStateText(EBackupState::STATE_RUNNING))); - state Key destPath = destUidValue.withPrefix(backupLogKeys.begin); + state Key destPath = destUidValue.withPrefix(backupLogKeys.begin); // Start logging the mutations for the specified ranges of the tag for (auto &backupRange : backupRanges) { srcTr2->set(logRangesEncodeKey(backupRange.begin, BinaryReader::fromStringRef(destUidValue, Unversioned())), logRangesEncodeValue(backupRange.end, destPath)); @@ -1666,9 +1670,10 @@ namespace dbBackup { tr->set(logUidValue.withPrefix(applyMutationsBeginRange.begin), BinaryWriter::toValue(beginVersion, Unversioned())); tr->set(logUidValue.withPrefix(applyMutationsEndRange.begin), BinaryWriter::toValue(beginVersion, Unversioned())); - tr->set(states.pack(DatabaseBackupAgent::keyStateStatus), StringRef(BackupAgentBase::getStateText(BackupAgentBase::STATE_RUNNING))); + tr->set(states.pack(DatabaseBackupAgent::keyStateStatus), + StringRef(BackupAgentBase::getStateText(EBackupState::STATE_RUNNING))); - state Reference kvBackupRangeComplete = futureBucket->future(tr); + state Reference kvBackupRangeComplete = futureBucket->future(tr); state Reference kvBackupComplete = futureBucket->future(tr); state int rangeCount = 0; @@ -1851,7 +1856,8 @@ public: } // This method will return the final status of the backup - ACTOR static Future waitBackup(DatabaseBackupAgent* backupAgent, Database cx, Key tagName, bool stopWhenDone) { + ACTOR static Future waitBackup(DatabaseBackupAgent* backupAgent, Database cx, Key tagName, + bool stopWhenDone) { state std::string backTrace; state UID logUid = wait(backupAgent->getLogUid(cx, tagName)); state Key statusKey = backupAgent->states.get(BinaryWriter::toValue(logUid, Unversioned())).pack(DatabaseBackupAgent::keyStateStatus); @@ -1862,15 +1868,15 @@ public: tr->setOption(FDBTransactionOptions::LOCK_AWARE); try { - state int status = wait(backupAgent->getStateValue(tr, logUid)); + state EBackupState status = wait(backupAgent->getStateValue(tr, logUid)); // Break, if no longer runnable - if (!DatabaseBackupAgent::isRunnable((BackupAgentBase::enumState)status) || BackupAgentBase::STATE_PARTIALLY_ABORTED == status) { + if (!DatabaseBackupAgent::isRunnable(status) || EBackupState::STATE_PARTIALLY_ABORTED == status) { return status; } // Break, if in differential mode (restorable) and stopWhenDone is not enabled - if ((!stopWhenDone) && (BackupAgentBase::STATE_RUNNING_DIFFERENTIAL == status)) { + if ((!stopWhenDone) && (EBackupState::STATE_RUNNING_DIFFERENTIAL == status)) { return status; } @@ -1885,7 +1891,7 @@ public: } // This method will return the final status of the backup - ACTOR static Future waitSubmitted(DatabaseBackupAgent* backupAgent, Database cx, Key tagName) { + ACTOR static Future waitSubmitted(DatabaseBackupAgent* backupAgent, Database cx, Key tagName) { state UID logUid = wait(backupAgent->getLogUid(cx, tagName)); state Key statusKey = backupAgent->states.get(BinaryWriter::toValue(logUid, Unversioned())).pack(DatabaseBackupAgent::keyStateStatus); @@ -1895,10 +1901,10 @@ public: tr->setOption(FDBTransactionOptions::LOCK_AWARE); try { - state int status = wait(backupAgent->getStateValue(tr, logUid)); + state EBackupState status = wait(backupAgent->getStateValue(tr, logUid)); // Break, if no longer runnable - if( BackupAgentBase::STATE_SUBMITTED != status) { + if (EBackupState::STATE_SUBMITTED != status) { return status; } @@ -1924,9 +1930,9 @@ public: tr->setOption(FDBTransactionOptions::COMMIT_ON_FIRST_PROXY); // We will use the global status for now to ensure that multiple backups do not start place with different tags - state int status = wait(backupAgent->getStateValue(tr, logUidCurrent)); + state EBackupState status = wait(backupAgent->getStateValue(tr, logUidCurrent)); - if (DatabaseBackupAgent::isRunnable((BackupAgentBase::enumState)status)) { + if (DatabaseBackupAgent::isRunnable(status)) { throw backup_duplicate(); } @@ -1987,7 +1993,8 @@ public: tr->set(backupAgent->config.get(logUidValue).pack(DatabaseBackupAgent::keyFolderId), backupUid); tr->set(backupAgent->states.get(logUidValue).pack(DatabaseBackupAgent::keyFolderId), backupUid); // written to config and states because it's also used by abort tr->set(backupAgent->config.get(logUidValue).pack(DatabaseBackupAgent::keyConfigBackupRanges), BinaryWriter::toValue(backupRanges, IncludeVersion(ProtocolVersion::withDRBackupRanges()))); - tr->set(backupAgent->states.get(logUidValue).pack(DatabaseBackupAgent::keyStateStatus), StringRef(BackupAgentBase::getStateText(BackupAgentBase::STATE_SUBMITTED))); + tr->set(backupAgent->states.get(logUidValue).pack(DatabaseBackupAgent::keyStateStatus), + StringRef(BackupAgentBase::getStateText(EBackupState::STATE_SUBMITTED))); if (stopWhenDone) { tr->set(backupAgent->config.get(logUidValue).pack(DatabaseBackupAgent::keyConfigStopWhenDoneKey), StringRef()); } @@ -2033,10 +2040,10 @@ public: ACTOR static Future atomicSwitchover(DatabaseBackupAgent* backupAgent, Database dest, Key tagName, Standalone> backupRanges, Key addPrefix, Key removePrefix, bool forceAction) { state DatabaseBackupAgent drAgent(dest); state UID destlogUid = wait(backupAgent->getLogUid(dest, tagName)); - state int status = wait(backupAgent->getStateValue(dest, destlogUid)); + state EBackupState status = wait(backupAgent->getStateValue(dest, destlogUid)); TraceEvent("DBA_SwitchoverStart").detail("Status", status); - if (status != BackupAgentBase::STATE_RUNNING_DIFFERENTIAL && status != BackupAgentBase::STATE_COMPLETED) { + if (status != EBackupState::STATE_RUNNING_DIFFERENTIAL && status != EBackupState::STATE_COMPLETED) { throw backup_duplicate(); } @@ -2153,10 +2160,10 @@ public: ACTOR static Future discontinueBackup(DatabaseBackupAgent* backupAgent, Reference tr, Key tagName) { tr->setOption(FDBTransactionOptions::LOCK_AWARE); state UID logUid = wait(backupAgent->getLogUid(tr, tagName)); - state int status = wait(backupAgent->getStateValue(tr, logUid)); + state EBackupState status = wait(backupAgent->getStateValue(tr, logUid)); TraceEvent("DBA_Discontinue").detail("Status", status); - if (!DatabaseBackupAgent::isRunnable((BackupAgentBase::enumState)status)) { + if (!DatabaseBackupAgent::isRunnable(status)) { throw backup_unneeded(); } @@ -2189,7 +2196,7 @@ public: logUid = _logUid; logUidValue = BinaryWriter::toValue(logUid, Unversioned()); - state Future statusFuture= backupAgent->getStateValue(tr, logUid); + state Future statusFuture = backupAgent->getStateValue(tr, logUid); state Future destUidFuture = backupAgent->getDestUid(tr, logUid); wait(success(statusFuture) && success(destUidFuture)); @@ -2197,8 +2204,8 @@ public: if (destUid.isValid()) { destUidValue = BinaryWriter::toValue(destUid, Unversioned()); } - int status = statusFuture.get(); - if (!backupAgent->isRunnable((BackupAgentBase::enumState)status)) { + EBackupState status = statusFuture.get(); + if (!backupAgent->isRunnable(status)) { throw backup_unneeded(); } @@ -2213,7 +2220,8 @@ public: tr->clear(prefixRange(logUidValue.withPrefix(applyLogKeys.begin))); - tr->set(StringRef(backupAgent->states.get(logUidValue).pack(DatabaseBackupAgent::keyStateStatus)), StringRef(DatabaseBackupAgent::getStateText(BackupAgentBase::STATE_PARTIALLY_ABORTED))); + tr->set(StringRef(backupAgent->states.get(logUidValue).pack(DatabaseBackupAgent::keyStateStatus)), + StringRef(DatabaseBackupAgent::getStateText(EBackupState::STATE_PARTIALLY_ABORTED))); wait(tr->commit()); TraceEvent("DBA_Abort").detail("CommitVersion", tr->getCommittedVersion()); @@ -2286,7 +2294,8 @@ public: } if (abortOldBackup) { - srcTr->set( backupAgent->sourceStates.pack(DatabaseBackupAgent::keyStateStatus), StringRef(BackupAgentBase::getStateText(BackupAgentBase::STATE_ABORTED) )); + srcTr->set(backupAgent->sourceStates.pack(DatabaseBackupAgent::keyStateStatus), + StringRef(BackupAgentBase::getStateText(EBackupState::STATE_ABORTED))); srcTr->set( backupAgent->sourceStates.get(logUidValue).pack(DatabaseBackupAgent::keyFolderId), backupUid ); srcTr->clear(prefixRange(logUidValue.withPrefix(backupLogKeys.begin))); srcTr->clear(prefixRange(logUidValue.withPrefix(logRangesRange.begin))); @@ -2307,7 +2316,8 @@ public: break; } - srcTr->set( backupAgent->sourceStates.pack(DatabaseBackupAgent::keyStateStatus), StringRef(DatabaseBackupAgent::getStateText(BackupAgentBase::STATE_PARTIALLY_ABORTED) )); + srcTr->set(backupAgent->sourceStates.pack(DatabaseBackupAgent::keyStateStatus), + StringRef(DatabaseBackupAgent::getStateText(EBackupState::STATE_PARTIALLY_ABORTED))); srcTr->set( backupAgent->sourceStates.get(logUidValue).pack(DatabaseBackupAgent::keyFolderId), backupUid ); wait( eraseLogData(srcTr, logUidValue, destUidValue) || partialTimeout ); @@ -2341,7 +2351,8 @@ public: return Void(); } - tr->set(StringRef(backupAgent->states.get(logUidValue).pack(DatabaseBackupAgent::keyStateStatus)), StringRef(DatabaseBackupAgent::getStateText(BackupAgentBase::STATE_ABORTED))); + tr->set(StringRef(backupAgent->states.get(logUidValue).pack(DatabaseBackupAgent::keyStateStatus)), + StringRef(DatabaseBackupAgent::getStateText(EBackupState::STATE_ABORTED))); wait(tr->commit()); @@ -2382,13 +2393,11 @@ public: state Future> fStopVersionKey = tr->get(backupAgent->states.get(BinaryWriter::toValue(logUid, Unversioned())).pack(BackupAgentBase::keyStateStop)); state Future> fBackupKeysPacked = tr->get(backupAgent->config.get(BinaryWriter::toValue(logUid, Unversioned())).pack(BackupAgentBase::keyConfigBackupRanges)); - int backupStateInt = wait(backupAgent->getStateValue(tr, logUid)); - state BackupAgentBase::enumState backupState = (BackupAgentBase::enumState)backupStateInt; - - if (backupState == DatabaseBackupAgent::STATE_NEVERRAN) { + state EBackupState backupState = wait(backupAgent->getStateValue(tr, logUid)); + + if (backupState == EBackupState::STATE_NEVERRAN) { statusText += "No previous backups found.\n"; - } - else { + } else { state std::string tagNameDisplay; Optional tagName = wait(fTagName); @@ -2408,23 +2417,20 @@ public: } switch (backupState) { - case BackupAgentBase::STATE_SUBMITTED: + case EBackupState::STATE_SUBMITTED: statusText += "The DR on tag `" + tagNameDisplay + "' is NOT a complete copy of the primary database (just started).\n"; break; - case BackupAgentBase::STATE_RUNNING: + case EBackupState::STATE_RUNNING: statusText += "The DR on tag `" + tagNameDisplay + "' is NOT a complete copy of the primary database.\n"; break; - case BackupAgentBase::STATE_RUNNING_DIFFERENTIAL: + case EBackupState::STATE_RUNNING_DIFFERENTIAL: statusText += "The DR on tag `" + tagNameDisplay + "' is a complete copy of the primary database.\n"; break; - case BackupAgentBase::STATE_COMPLETED: - { + case EBackupState::STATE_COMPLETED: { Version stopVersion = stopVersionKey.present() ? BinaryReader::fromStringRef(stopVersionKey.get(), Unversioned()) : -1; statusText += "The previous DR on tag `" + tagNameDisplay + "' completed at version " + format("%lld", stopVersion) + ".\n"; - } - break; - case BackupAgentBase::STATE_PARTIALLY_ABORTED: - { + } break; + case EBackupState::STATE_PARTIALLY_ABORTED: { statusText += "The previous DR on tag `" + tagNameDisplay + "' " + BackupAgentBase::getStateText(backupState) + ".\n"; statusText += "Abort the DR with --cleanup before starting a new DR.\n"; break; @@ -2485,13 +2491,15 @@ public: return statusText; } - ACTOR static Future getStateValue(DatabaseBackupAgent* backupAgent, Reference tr, UID logUid, bool snapshot) { + ACTOR static Future getStateValue(DatabaseBackupAgent* backupAgent, + Reference tr, UID logUid, + bool snapshot) { tr->setOption(FDBTransactionOptions::ACCESS_SYSTEM_KEYS); tr->setOption(FDBTransactionOptions::LOCK_AWARE); state Key statusKey = backupAgent->states.get(BinaryWriter::toValue(logUid, Unversioned())).pack(DatabaseBackupAgent::keyStateStatus); Optional status = wait(tr->get(statusKey, snapshot)); - return (!status.present()) ? DatabaseBackupAgent::STATE_NEVERRAN : BackupAgentBase::getState(status.get().toString()); + return (!status.present()) ? EBackupState::STATE_NEVERRAN : BackupAgentBase::getState(status.get().toString()); } ACTOR static Future getDestUid(DatabaseBackupAgent* backupAgent, Reference tr, UID logUid, bool snapshot) { @@ -2536,7 +2544,8 @@ Future DatabaseBackupAgent::getStatus(Database cx, int errorLimit, return DatabaseBackupAgentImpl::getStatus(this, cx, errorLimit, tagName); } -Future DatabaseBackupAgent::getStateValue(Reference tr, UID logUid, bool snapshot) { +Future DatabaseBackupAgent::getStateValue(Reference tr, UID logUid, + bool snapshot) { return DatabaseBackupAgentImpl::getStateValue(this, tr, logUid, snapshot); } @@ -2552,11 +2561,11 @@ Future DatabaseBackupAgent::waitUpgradeToLatestDrVersion(Database cx, Key return DatabaseBackupAgentImpl::waitUpgradeToLatestDrVersion(this, cx, tagName); } -Future DatabaseBackupAgent::waitBackup(Database cx, Key tagName, bool stopWhenDone) { +Future DatabaseBackupAgent::waitBackup(Database cx, Key tagName, bool stopWhenDone) { return DatabaseBackupAgentImpl::waitBackup(this, cx, tagName, stopWhenDone); } -Future DatabaseBackupAgent::waitSubmitted(Database cx, Key tagName) { +Future DatabaseBackupAgent::waitSubmitted(Database cx, Key tagName) { return DatabaseBackupAgentImpl::waitSubmitted(this, cx, tagName); } diff --git a/fdbclient/FileBackupAgent.actor.cpp b/fdbclient/FileBackupAgent.actor.cpp index 7b8833431e..cc958fe4d8 100644 --- a/fdbclient/FileBackupAgent.actor.cpp +++ b/fdbclient/FileBackupAgent.actor.cpp @@ -748,9 +748,10 @@ namespace fileBackup { state Subspace newConfigSpace = uidPrefixKey(LiteralStringRef("uid->config/").withPrefix(fileBackupPrefixRange.begin), uid); Optional statusStr = wait(tr->get(statusSpace.pack(FileBackupAgent::keyStateStatus))); - state EBackupState status = !statusStr.present() ? FileBackupAgent::STATE_NEVERRAN : BackupAgentBase::getState(statusStr.get().toString()); + state EBackupState status = + !statusStr.present() ? EBackupState::STATE_NEVERRAN : BackupAgentBase::getState(statusStr.get().toString()); - TraceEvent(SevInfo, "FileBackupAbortIncompatibleBackup") + TraceEvent(SevInfo, "FileBackupAbortIncompatibleBackup") .detail("TagName", tagName.c_str()) .detail("Status", BackupAgentBase::getStateText(status)); @@ -770,9 +771,9 @@ namespace fileBackup { // Set old style state key to Aborted if it was Runnable if(backupAgent->isRunnable(status)) - tr->set(statusKey, StringRef(FileBackupAgent::getStateText(BackupAgentBase::STATE_ABORTED))); + tr->set(statusKey, StringRef(FileBackupAgent::getStateText(EBackupState::STATE_ABORTED))); - return Void(); + return Void(); } struct AbortFiveZeroBackupTask : TaskFuncBase { @@ -822,11 +823,11 @@ namespace fileBackup { state BackupConfig config(current.first); EBackupState status = wait(config.stateEnum().getD(tr, false, EBackupState::STATE_NEVERRAN)); - if (!backupAgent->isRunnable((BackupAgentBase::enumState)status)) { - throw backup_unneeded(); - } + if (!backupAgent->isRunnable(status)) { + throw backup_unneeded(); + } - TraceEvent(SevInfo, "FBA_AbortFileOneBackup") + TraceEvent(SevInfo, "FBA_AbortFileOneBackup") .detail("TagName", tagName.c_str()) .detail("Status", BackupAgentBase::getStateText(status)); @@ -2100,10 +2101,10 @@ namespace fileBackup { } // If the backup is restorable but the state is not differential then set state to differential - if(restorableVersion.present() && backupState != BackupAgentBase::STATE_RUNNING_DIFFERENTIAL) - config.stateEnum().set(tr, BackupAgentBase::STATE_RUNNING_DIFFERENTIAL); + if (restorableVersion.present() && backupState != EBackupState::STATE_RUNNING_DIFFERENTIAL) + config.stateEnum().set(tr, EBackupState::STATE_RUNNING_DIFFERENTIAL); - // If stopWhenDone is set and there is a restorable version, set the done future and do not create further tasks. + // If stopWhenDone is set and there is a restorable version, set the done future and do not create further tasks. if(stopWhenDone && restorableVersion.present()) { wait(onDone->set(tr, taskBucket) && taskBucket->finish(tr, task)); @@ -2350,10 +2351,10 @@ namespace fileBackup { } // If the backup is restorable and the state isn't differential the set state to differential - if(restorableVersion.present() && backupState != BackupAgentBase::STATE_RUNNING_DIFFERENTIAL) - config.stateEnum().set(tr, BackupAgentBase::STATE_RUNNING_DIFFERENTIAL); + if (restorableVersion.present() && backupState != EBackupState::STATE_RUNNING_DIFFERENTIAL) + config.stateEnum().set(tr, EBackupState::STATE_RUNNING_DIFFERENTIAL); - // Unless we are to stop, start the next snapshot using the default interval + // Unless we are to stop, start the next snapshot using the default interval Reference snapshotDoneFuture = task->getDoneFuture(futureBucket); if(!stopWhenDone) { wait(config.initNewSnapshot(tr) && success(BackupSnapshotDispatchTask::addTask(tr, taskBucket, task, 1, TaskCompletionKey::signal(snapshotDoneFuture)))); @@ -3746,7 +3747,9 @@ public: // This method will return the final status of the backup at tag, and return the URL that was used on the tag // when that status value was read. - ACTOR static Future waitBackup(FileBackupAgent* backupAgent, Database cx, std::string tagName, bool stopWhenDone, Reference *pContainer = nullptr, UID *pUID = nullptr) { + ACTOR static Future waitBackup(FileBackupAgent* backupAgent, Database cx, std::string tagName, + bool stopWhenDone, Reference* pContainer = nullptr, + UID* pUID = nullptr) { state std::string backTrace; state KeyBackedTag tag = makeBackupTag(tagName); @@ -3767,7 +3770,8 @@ public: // Break, if one of the following is true // - no longer runnable // - in differential mode (restorable) and stopWhenDone is not enabled - if( !FileBackupAgent::isRunnable(status) || ((!stopWhenDone) && (BackupAgentBase::STATE_RUNNING_DIFFERENTIAL == status) )) { + if (!FileBackupAgent::isRunnable(status) || + ((!stopWhenDone) && (EBackupState::STATE_RUNNING_DIFFERENTIAL == status))) { if(pContainer != nullptr) { Reference c = wait(config.backupContainer().getOrThrow(tr, false, backup_invalid_info())); @@ -4103,7 +4107,7 @@ public: state Key destUidValue = wait(config.destUidValue().getOrThrow(tr)); EBackupState status = wait(config.stateEnum().getD(tr, false, EBackupState::STATE_NEVERRAN)); - if (!backupAgent->isRunnable((BackupAgentBase::enumState)status)) { + if (!backupAgent->isRunnable(status)) { throw backup_unneeded(); } @@ -4206,13 +4210,13 @@ public: JsonBuilderObject statusDoc; statusDoc.setKey("Name", BackupAgentBase::getStateName(backupState)); statusDoc.setKey("Description", BackupAgentBase::getStateText(backupState)); - statusDoc.setKey("Completed", backupState == BackupAgentBase::STATE_COMPLETED); + statusDoc.setKey("Completed", backupState == EBackupState::STATE_COMPLETED); statusDoc.setKey("Running", BackupAgentBase::isRunnable(backupState)); doc.setKey("Status", statusDoc); state Future done = Void(); - if(backupState != BackupAgentBase::STATE_NEVERRAN) { + if (backupState != EBackupState::STATE_NEVERRAN) { state Reference bc; state TimestampedVersion latestRestorable; @@ -4224,7 +4228,7 @@ public: if(latestRestorable.present()) { JsonBuilderObject o = latestRestorable.toJSON(); - if(backupState != BackupAgentBase::STATE_COMPLETED) { + if (backupState != EBackupState::STATE_COMPLETED) { o.setKey("LagSeconds", (recentReadVersion - latestRestorable.version.get()) / CLIENT_KNOBS->CORE_VERSIONSPERSECOND); } doc.setKey("LatestRestorablePoint", o); @@ -4232,7 +4236,8 @@ public: doc.setKey("DestinationURL", bc->getURL()); } - if(backupState == BackupAgentBase::STATE_RUNNING_DIFFERENTIAL || backupState == BackupAgentBase::STATE_RUNNING) { + if (backupState == EBackupState::STATE_RUNNING_DIFFERENTIAL || + backupState == EBackupState::STATE_RUNNING) { state int64_t snapshotInterval; state int64_t logBytesWritten; state int64_t rangeBytesWritten; @@ -4355,23 +4360,28 @@ public: bool snapshotProgress = false; switch (backupState) { - case BackupAgentBase::STATE_SUBMITTED: - statusText += "The backup on tag `" + tagName + "' is in progress (just started) to " + bc->getURL() + ".\n"; - break; - case BackupAgentBase::STATE_RUNNING: - statusText += "The backup on tag `" + tagName + "' is in progress to " + bc->getURL() + ".\n"; - snapshotProgress = true; - break; - case BackupAgentBase::STATE_RUNNING_DIFFERENTIAL: - statusText += "The backup on tag `" + tagName + "' is restorable but continuing to " + bc->getURL() + ".\n"; - snapshotProgress = true; - break; - case BackupAgentBase::STATE_COMPLETED: - statusText += "The previous backup on tag `" + tagName + "' at " + bc->getURL() + " completed at version " + format("%lld", latestRestorableVersion.orDefault(-1)) + ".\n"; - break; - default: - statusText += "The previous backup on tag `" + tagName + "' at " + bc->getURL() + " " + backupStatus + ".\n"; - break; + case EBackupState::STATE_SUBMITTED: + statusText += "The backup on tag `" + tagName + "' is in progress (just started) to " + + bc->getURL() + ".\n"; + break; + case EBackupState::STATE_RUNNING: + statusText += "The backup on tag `" + tagName + "' is in progress to " + bc->getURL() + ".\n"; + snapshotProgress = true; + break; + case EBackupState::STATE_RUNNING_DIFFERENTIAL: + statusText += "The backup on tag `" + tagName + "' is restorable but continuing to " + + bc->getURL() + ".\n"; + snapshotProgress = true; + break; + case EBackupState::STATE_COMPLETED: + statusText += "The previous backup on tag `" + tagName + "' at " + bc->getURL() + + " completed at version " + format("%lld", latestRestorableVersion.orDefault(-1)) + + ".\n"; + break; + default: + statusText += "The previous backup on tag `" + tagName + "' at " + bc->getURL() + " " + + backupStatus + ".\n"; + break; } statusText += format("BackupUID: %s\n", uidAndAbortedFlag.get().first.toString().c_str()); statusText += format("BackupURL: %s\n", bc->getURL().c_str()); @@ -4407,7 +4417,7 @@ public: ); statusText += format("Snapshot interval is %lld seconds. ", snapshotInterval); - if(backupState == BackupAgentBase::STATE_RUNNING_DIFFERENTIAL) + if (backupState == EBackupState::STATE_RUNNING_DIFFERENTIAL) statusText += format("Current snapshot progress target is %3.2f%% (>100%% means the snapshot is supposed to be done)\n", 100.0 * (recentReadVersion - snapshotBeginVersion) / (snapshotTargetEndVersion - snapshotBeginVersion)) ; else statusText += "The initial snapshot is still running.\n"; @@ -4565,7 +4575,7 @@ public: backupConfig = BackupConfig(uidFlag.first); state EBackupState status = wait(backupConfig.stateEnum().getOrThrow(ryw_tr)); - if (status != BackupAgentBase::STATE_RUNNING_DIFFERENTIAL ) { + if (status != EBackupState::STATE_RUNNING_DIFFERENTIAL) { throw backup_duplicate(); } @@ -4766,7 +4776,8 @@ void FileBackupAgent::setLastRestorable(Reference tr, tr->set(lastRestorable.pack(tagName), BinaryWriter::toValue(version, Unversioned())); } -Future FileBackupAgent::waitBackup(Database cx, std::string tagName, bool stopWhenDone, Reference *pContainer, UID *pUID) { +Future FileBackupAgent::waitBackup(Database cx, std::string tagName, bool stopWhenDone, + Reference* pContainer, UID* pUID) { return FileBackupAgentImpl::waitBackup(this, cx, tagName, stopWhenDone, pContainer, pUID); } diff --git a/fdbserver/workloads/BackupAndParallelRestoreCorrectness.actor.cpp b/fdbserver/workloads/BackupAndParallelRestoreCorrectness.actor.cpp index af983a13ee..39ba539430 100644 --- a/fdbserver/workloads/BackupAndParallelRestoreCorrectness.actor.cpp +++ b/fdbserver/workloads/BackupAndParallelRestoreCorrectness.actor.cpp @@ -237,9 +237,12 @@ struct BackupAndParallelRestoreCorrectnessWorkload : TestWorkload { // Wait until the backup is in a restorable state and get the status, URL, and UID atomically state Reference lastBackupContainer; state UID lastBackupUID; - state int resultWait = wait(backupAgent->waitBackup(cx, backupTag.tagName, false, &lastBackupContainer, &lastBackupUID)); + state EBackupState resultWait = wait( + backupAgent->waitBackup(cx, backupTag.tagName, false, &lastBackupContainer, &lastBackupUID)); - TraceEvent("BARW_DoBackupWaitForRestorable", randomID).detail("Tag", backupTag.tagName).detail("Result", resultWait); + TraceEvent("BARW_DoBackupWaitForRestorable", randomID) + .detail("Tag", backupTag.tagName) + .detail("Result", BackupAgentBase::getStateText(resultWait)); state bool restorable = false; if (lastBackupContainer) { @@ -255,23 +258,28 @@ struct BackupAndParallelRestoreCorrectnessWorkload : TestWorkload { } TraceEvent("BARW_LastBackupContainer", randomID) - .detail("BackupTag", printable(tag)) - .detail("LastBackupContainer", lastBackupContainer ? lastBackupContainer->getURL() : "") - .detail("LastBackupUID", lastBackupUID).detail("WaitStatus", resultWait).detail("Restorable", restorable); + .detail("BackupTag", printable(tag)) + .detail("LastBackupContainer", lastBackupContainer ? lastBackupContainer->getURL() : "") + .detail("LastBackupUID", lastBackupUID) + .detail("WaitStatus", BackupAgentBase::getStateText(resultWait)) + .detail("Restorable", restorable); // Do not check the backup, if aborted - if (resultWait == BackupAgentBase::STATE_ABORTED) { + if (resultWait == EBackupState::STATE_ABORTED) { } // Ensure that a backup container was found else if (!lastBackupContainer) { TraceEvent(SevError, "BARW_MissingBackupContainer", randomID).detail("LastBackupUID", lastBackupUID).detail("BackupTag", printable(tag)).detail("WaitStatus", resultWait); - printf("BackupCorrectnessMissingBackupContainer tag: %s status: %d\n", - printable(tag).c_str(), resultWait); + printf("BackupCorrectnessMissingBackupContainer tag: %s status: %s\n", + printable(tag).c_str(), BackupAgentBase::getStateText(resultWait)); } // Check that backup is restorable - else if(!restorable) { - TraceEvent(SevError, "BARW_NotRestorable", randomID).detail("LastBackupUID", lastBackupUID).detail("BackupTag", printable(tag)) - .detail("BackupFolder", lastBackupContainer->getURL()).detail("WaitStatus", resultWait); + else if (!restorable) { + TraceEvent(SevError, "BARW_NotRestorable", randomID) + .detail("LastBackupUID", lastBackupUID) + .detail("BackupTag", printable(tag)) + .detail("BackupFolder", lastBackupContainer->getURL()) + .detail("WaitStatus", BackupAgentBase::getStateText(resultWait)); printf("BackupCorrectnessNotRestorable: tag: %s\n", printable(tag).c_str()); } @@ -280,7 +288,7 @@ struct BackupAndParallelRestoreCorrectnessWorkload : TestWorkload { if (startDelay) { TraceEvent("BARW_DoBackupAbortBackup2", randomID) .detail("Tag", printable(tag)) - .detail("WaitStatus", resultWait) + .detail("WaitStatus", BackupAgentBase::getStateText(resultWait)) .detail("LastBackupContainer", lastBackupContainer ? lastBackupContainer->getURL() : "") .detail("Restorable", restorable); wait(backupAgent->abortBackup(cx, tag.toString())); @@ -306,7 +314,7 @@ struct BackupAndParallelRestoreCorrectnessWorkload : TestWorkload { // Wait for the backup to complete TraceEvent("BARW_DoBackupWaitBackup", randomID).detail("Tag", printable(tag)); - state int statusValue = wait(backupAgent->waitBackup(cx, tag.toString(), true)); + state EBackupState statusValue = wait(backupAgent->waitBackup(cx, tag.toString(), true)); state std::string statusText; @@ -317,7 +325,7 @@ struct BackupAndParallelRestoreCorrectnessWorkload : TestWorkload { TraceEvent("BARW_DoBackupComplete", randomID) .detail("Tag", printable(tag)) .detail("Status", statusText) - .detail("StatusValue", statusValue); + .detail("StatusValue", BackupAgentBase::getStateText(statusValue)); return Void(); } diff --git a/fdbserver/workloads/BackupCorrectness.actor.cpp b/fdbserver/workloads/BackupCorrectness.actor.cpp index 080562d1bf..f1eb1c6b9b 100644 --- a/fdbserver/workloads/BackupCorrectness.actor.cpp +++ b/fdbserver/workloads/BackupCorrectness.actor.cpp @@ -250,9 +250,12 @@ struct BackupAndRestoreCorrectnessWorkload : TestWorkload { // Wait until the backup is in a restorable state and get the status, URL, and UID atomically state Reference lastBackupContainer; state UID lastBackupUID; - state int resultWait = wait(backupAgent->waitBackup(cx, backupTag.tagName, false, &lastBackupContainer, &lastBackupUID)); + state EBackupState resultWait = wait( + backupAgent->waitBackup(cx, backupTag.tagName, false, &lastBackupContainer, &lastBackupUID)); - TraceEvent("BARW_DoBackupWaitForRestorable", randomID).detail("Tag", backupTag.tagName).detail("Result", resultWait); + TraceEvent("BARW_DoBackupWaitForRestorable", randomID) + .detail("Tag", backupTag.tagName) + .detail("Result", BackupAgentBase::getStateText(resultWait)); state bool restorable = false; if(lastBackupContainer) { @@ -268,31 +271,41 @@ struct BackupAndRestoreCorrectnessWorkload : TestWorkload { } TraceEvent("BARW_LastBackupContainer", randomID) - .detail("BackupTag", printable(tag)) - .detail("LastBackupContainer", lastBackupContainer ? lastBackupContainer->getURL() : "") - .detail("LastBackupUID", lastBackupUID).detail("WaitStatus", resultWait).detail("Restorable", restorable); + .detail("BackupTag", printable(tag)) + .detail("LastBackupContainer", lastBackupContainer ? lastBackupContainer->getURL() : "") + .detail("LastBackupUID", lastBackupUID) + .detail("WaitStatus", BackupAgentBase::getStateText(resultWait)) + .detail("Restorable", restorable); // Do not check the backup, if aborted - if (resultWait == BackupAgentBase::STATE_ABORTED) { + if (resultWait == EBackupState::STATE_ABORTED) { } // Ensure that a backup container was found else if (!lastBackupContainer) { - TraceEvent(SevError, "BARW_MissingBackupContainer", randomID).detail("LastBackupUID", lastBackupUID).detail("BackupTag", printable(tag)).detail("WaitStatus", resultWait); - printf("BackupCorrectnessMissingBackupContainer tag: %s status: %d\n", printable(tag).c_str(), resultWait); + TraceEvent(SevError, "BARW_MissingBackupContainer", randomID) + .detail("LastBackupUID", lastBackupUID) + .detail("BackupTag", printable(tag)) + .detail("WaitStatus", BackupAgentBase::getStateText(resultWait)); + printf("BackupCorrectnessMissingBackupContainer tag: %s status: %s\n", + printable(tag).c_str(), BackupAgentBase::getStateText(resultWait)); } // Check that backup is restorable - else if(!restorable) { - TraceEvent(SevError, "BARW_NotRestorable", randomID).detail("LastBackupUID", lastBackupUID).detail("BackupTag", printable(tag)) - .detail("BackupFolder", lastBackupContainer->getURL()).detail("WaitStatus", resultWait); + else if (!restorable) { + TraceEvent(SevError, "BARW_NotRestorable", randomID) + .detail("LastBackupUID", lastBackupUID) + .detail("BackupTag", printable(tag)) + .detail("BackupFolder", lastBackupContainer->getURL()) + .detail("WaitStatus", BackupAgentBase::getStateText(resultWait)); printf("BackupCorrectnessNotRestorable: tag: %s\n", printable(tag).c_str()); } // Abort the backup, if not the first backup because the second backup may have aborted the backup by now if (startDelay) { - TraceEvent("BARW_DoBackupAbortBackup2", randomID).detail("Tag", printable(tag)) - .detail("WaitStatus", resultWait) - .detail("LastBackupContainer", lastBackupContainer ? lastBackupContainer->getURL() : "") - .detail("Restorable", restorable); + TraceEvent("BARW_DoBackupAbortBackup2", randomID) + .detail("Tag", printable(tag)) + .detail("WaitStatus", BackupAgentBase::getStateText(resultWait)) + .detail("LastBackupContainer", lastBackupContainer ? lastBackupContainer->getURL() : "") + .detail("Restorable", restorable); wait(backupAgent->abortBackup(cx, tag.toString())); } else { @@ -315,7 +328,7 @@ struct BackupAndRestoreCorrectnessWorkload : TestWorkload { // Wait for the backup to complete TraceEvent("BARW_DoBackupWaitBackup", randomID).detail("Tag", printable(tag)); - state int statusValue = wait(backupAgent->waitBackup(cx, tag.toString(), true)); + state EBackupState statusValue = wait(backupAgent->waitBackup(cx, tag.toString(), true)); state std::string statusText; @@ -323,8 +336,10 @@ struct BackupAndRestoreCorrectnessWorkload : TestWorkload { statusText = _statusText; // Can we validate anything about status? - TraceEvent("BARW_DoBackupComplete", randomID).detail("Tag", printable(tag)) - .detail("Status", statusText).detail("StatusValue", statusValue); + TraceEvent("BARW_DoBackupComplete", randomID) + .detail("Tag", printable(tag)) + .detail("Status", statusText) + .detail("StatusValue", BackupAgentBase::getStateText(statusValue)); return Void(); } diff --git a/fdbserver/workloads/BackupToDBCorrectness.actor.cpp b/fdbserver/workloads/BackupToDBCorrectness.actor.cpp index b71a5a4adb..d058f408b2 100644 --- a/fdbserver/workloads/BackupToDBCorrectness.actor.cpp +++ b/fdbserver/workloads/BackupToDBCorrectness.actor.cpp @@ -270,7 +270,7 @@ struct BackupToDBCorrectnessWorkload : TestWorkload { if (BUGGIFY) { TraceEvent("BARW_DoBackupWaitForRestorable", randomID).detail("Tag", printable(tag)); // Wait until the backup is in a restorable state - state int resultWait = wait(backupAgent->waitBackup(cx, tag, false)); + state EBackupState resultWait = wait(backupAgent->waitBackup(cx, tag, false)); TraceEvent("BARW_LastBackupFolder", randomID).detail("BackupTag", printable(tag)) .detail("LogUid", logUid).detail("WaitStatus", resultWait); @@ -309,7 +309,7 @@ struct BackupToDBCorrectnessWorkload : TestWorkload { UID _destUid = wait(backupAgent->getDestUid(cx, logUid)); self->destUid = _destUid; - state int statusValue = wait(backupAgent->waitBackup(cx, tag, true)); + state EBackupState statusValue = wait(backupAgent->waitBackup(cx, tag, true)); wait(backupAgent->unlockBackup(cx, tag)); state std::string statusText;